Mini proiect (50) - Conectarea și controlul unui modul RFID-RC522 cu ESP32

Publicat de pe

Conectarea și controlul unui modul RFID-RC522  cu ESP32 

Modulul RFID-RC522 este un dispozitiv de citire / scriere a cardurilor cu frecventa radio (RFID), care utilizează tehnologia de comunicare NFC (Near Field Communication). Acest dispozitiv funcționează prin intermediul unui cip integrat numit RC522, care poate citi și scrie date pe carduri RFID cu frecventa de 13.56 MHz.

Atunci când un card RFID compatibil este apropiat de modulul RC522, acesta poate citi informațiile stocate pe card prin intermediul unui câmp electromagnetic generat de antena modulului RC522. Dacă modulul RC522 are permisiunea de scriere, acesta poate, de asemenea, să scrie date pe card.

Modulul RC522 comunica cu un microcontroler, cum ar fi ESP32, prin intermediul interfeței SPI (Serial Peripheral Interface), oferind un flux de date bidirecțional între cele două dispozitive. Biblioteca MFRC522 poate fi folosită pentru a simplifica comunicarea intre ESP32 și RC522 prin intermediul librăriei SPI.

În concluzie, modulul RFID-RC522 funcționează prin intermediul unui câmp electromagnetic generat de antena sa, care permite citirea și scrierea de informații pe carduri RFID compatibile. Acesta poate fi conectat la orice microcontroler compatibil cu SPI pentru a realiza diverse proiecte cu RFID.

Cu ajutorul unui ESP32 și a unui modul RFID-RC522, puteți realiza o serie de proiecte interesante și utile. Iată câteva exemple:

  1. Sistem de acces cu card RFID - acesta poate fi folosit pentru a controla accesul la o încăpere sau la un sistem, permițând doar accesul utilizatorilor autorizați cu carduri compatibile.

  2. Gestionare de inventar - puteți utiliza un ESP32 și un modul RFID pentru a crea un sistem de scanare automata a produselor și a actualiza stocul în timp real.


  3. Sistem de plata - puteți crea un sistem de plata cu card RFID, permițând clienților sa efectueze plăti prin apropierea cardului de modul RFID.

  4. Citiți informații de pe un card RFID - puteți utiliza ESP32 si modulul RFID pentru a citi informațiile stocate pe un card RFID și a le afișa pe un ecran sau a le trimite prin intermediul conexiunii la internet.

Frecvențele de funcționare

Frecvența de funcționare a cititorului RFID depinde de tipul de RFID utilizat. Există trei tipuri principale de RFID: frecvența joasă (LF), frecvența înaltă (HF) și frecvența ultraînaltă (UHF).

Cititoarele RFID LF funcționează de obicei la o frecvență de 125 kHz sau 134 kHz. Cititoarele RFID HF funcționează la o frecvență de 13,56 MHz. Cititoarele RFID UHF funcționează la o frecvență cuprinsă între 860 MHz și 960 MHz.


Este important de menționat că frecvența de funcționare a cititorului RFID trebuie să se potrivească cu frecvența etichetei RFID pentru ca comunicarea să poată avea loc.

Cele trei tipuri de frecvențe sunt utilizate în diferite aplicații ale tehnologiei RFID:

- Frecvența joasă (LF) este adesea folosită pentru identificarea animalelor de companie, pentru sistemul de acces în clădiri sau pentru urmărirea obiectelor într-un depozit. Această frecvență oferă o gamă scurtă de citire, de obicei între 10 cm și 1 metru.

- Frecvența înaltă (HF) este utilizată în aplicații precum sistemul de plată fără contact sau în sectorul medical pentru a identifica dispozitive medicale. Această frecvență oferă o gamă medie de citire, de obicei între 10 cm și 1 metru.

- Frecvența ultraînaltă (UHF) este utilizată în aplicații precum urmărirea stocurilor sau a mărfurilor într-un depozit sau pentru a identifica produsele la punctele de vânzare. Această frecvență oferă o gamă mare de citire, de obicei între 1 și 10 metri.

Fiecare frecvență are avantaje și dezavantaje și este utilizată în funcție de cerințele aplicației specifice.

Reprezentarea informației

Informația în cadrul unui sistem RFID (Radio Frequency Identification) este reprezentată sub formă de semnale radio care sunt transmise între două componente ale sistemului: un tag RFID (etichetă) și un cititor RFID. Aceste semnale radio conțin date precum ID-ul tag-ului, tipul de tag sau alte informații specificate de utilizator.

Există două tipuri principale de tag-uri RFID: tag-uri pasive și tag-uri active. Tag-urile pasive nu au o sursă de alimentare internă și primesc puterea necesară pentru a funcționa de la undele radio emise de cititorul RFID. Tag-urile active au o sursă de alimentare internă (de obicei o baterie) și pot transmite semnale radio în mod activ.

Informația reprezentată de un tag RFID poate fi stocată în diferite moduri, în funcție de tipul de tag și de aplicația specifică. De exemplu, unele tag-uri RFID pot stoca informații în memoria EEPROM, iar altele pot fi programate pentru a se comporta ca niște senzori și pentru a transmite date despre mediul înconjurător.

În general, informația RFID poate fi interpretată și gestionată prin intermediul software-ului care comunică cu cititorul RFID și extrage datele din semnalele radio recepționate. Aceste date pot fi ulterior stocate în baze de date sau în alte formate de fișiere, în funcție de necesitățile aplicației.

Proiectarea antenei 

Antena este o componentă esențială a unui cititor RFID de frecvență joasă (LF). Antena transmite semnalele RF și primește semnalele înapoi de la tag-ul RFID. Proiectarea unei antene adecvate pentru un cititor RFID LF poate fi o sarcină dificilă, deoarece aceasta trebuie să fie adaptată la frecvența specifică a cititorului și la aplicația specifică.


În general, antenele pentru cititoarele RFID LF sunt de două tipuri principale: antene inductive și antene capacitiv-inductive. Antenele inductive utilizează un singur bobinaj și sunt mai ușor de realizat decât cele capacitiv-inductive, dar au o rază de acțiune mai mică. Antenele capacitiv-inductive sunt mai complexe, deoarece utilizează două bobine (inductivă și capacitivă) și oferă o rază de acțiune mai mare decât cele inductive.

Pentru a proiecta o antenă inductivă, sunt necesare cunoștințe de bază despre circuitele electrice și magnetice. În general, o antenă inductivă este realizată folosind un fir conductiv (de exemplu, cupru) înfășurat în jurul unui nucleu magnetic. Numărul de înfășurări ale firului poate afecta performanța antenei și trebuie determinat experimental.

Pentru a proiecta o antenă capacitiv-inductivă, este necesar să se ia în considerare nu numai numărul de înfășurări, ci și capacitățile și inductanțele componentelor utilizate. Această tipologie de antenă utilizează o bobină inductivă și o placă capacitivă pentru a îmbunătăți performanța.

În general, proiectarea unei antene pentru un cititor RFID LF poate fi o sarcină complexă și depinde de cerințele specifice ale aplicației. Este recomandat să se utilizeze software specializat de proiectare a antenelor, să se consulte literatura de specialitate și să se efectueze teste experimentale pentru a se asigura o performanță optimă a antenei.

 Componente

Schema electronica/sistem

Conectarea modulului RFID-RC522 la ESP32 se poate face prin intermediul mai multor pini de pe ESP32:

  • SDA - pin de date pentru comunicarea cu RC522
  • SCK - pin de clock pentru comunicarea cu RC522
  • MOSI - pin de date out pentru comunicarea cu RC522
  • MISO - pin de date in pentru comunicarea cu RC522
  • SS (slave select) - pin de selectare a SlaveSelect pentru comunicarea cu RC522
  • RST - pin de reset pentru RC522

Înainte de a începe conectarea fizica, trebuie sa vă asigurați compatibilitatea intre ESP32 și RC522 prin verificarea voltajelor și frecventelor de operare.În cazul nostru modului RFID MFRC522 opereză tot la 3.3v la fel ca și placa ESP32. De asemenea, este important sa folosiți un modul RC522 cu interfață SPI pentru a putea comunica cu ESP32.

Cod de test

 Biblioteca MFRC522 poate fi folosită pentru a simplifica comunicarea cu modulul RC522 prin intermediul librăriei SPI de pe ESP32. După conectarea fizica a pieselor, puteți folosi această bibliotecă pentru a realiza citirea și scrierea de date pe cardurile RFID compatibile.


/**
 * ----------------------------------------------------------------------------
 * This is a MFRC522 library example; see https://github.com/miguelbalboa/rfid
 * for further details and other examples.
 * 
 * NOTE: The library file MFRC522.h has a lot of useful info. Please read it.
 * 
 * Released into the public domain.
 * ----------------------------------------------------------------------------
 * Minimal example how to use the interrupts to read the UID of a MIFARE Classic PICC
 * (= card/tag).
 * 
 * 
 * Typical pin layout used:
 * -----------------------------------------------------------------------------------------
 *             MFRC522      Arduino       Arduino   Arduino    Arduino          Arduino
 *             Reader/PCD   Uno/101       Mega      Nano v3    Leonardo/Micro   Pro Micro
 * Signal      Pin          Pin           Pin       Pin        Pin              Pin
 * -----------------------------------------------------------------------------------------
 * RST/Reset   RST          9             5         D9         RESET/ICSP-5     RST
 * SPI SS      SDA(SS)      10            53        D10        3                10
 * IRQ         ?            ?             ?         ?          2                10
 * SPI MOSI    MOSI         11 / ICSP-4   51        D11        ICSP-4           16
 * SPI MISO    MISO         12 / ICSP-1   50        D12        ICSP-1           14
 * SPI SCK     SCK          13 / ICSP-3   52        D13        ICSP-3           15
 * 
 */
#include "Arduino.h"
#include "SPI.h"
#include "MFRC522.h"

#define RST_PIN 22 // Configurable, see typical pin layout above
#define SS_PIN 21  // Configurable, see typical pin layout above
#define SIZE_BUFFER 18
#define MAX_SIZE_BLOCK 16
#define LED_PIN 2

void dump_byte_array(byte *buffer, byte bufferSize);
void readingData();
int menu();
void writingData();
void showUID();


// used in authentication
MFRC522::MIFARE_Key key;
// authentication return status code
MFRC522::StatusCode status;
// Defined pins to module RC522
MFRC522 mfrc522(SS_PIN, RST_PIN);

int read_RFID = 255;
int write_RFID = 255;
int output;

/**
 * Initialize.
 */
void setup()
{

    Serial.begin(115200);

    SPI.begin(); // Init SPI bus

    // Init MFRC522
    mfrc522.PCD_Init();
    /* Initialize Buildin led pin (D2) for output */
    pinMode(LED_PIN, OUTPUT);
    Serial.println(" ");
    Serial.println("Approach your reader card...");
    Serial.println();
}

/**
 * Main loop.
 */
void loop() {

    // waiting the card approach
    if (!mfrc522.PICC_IsNewCardPresent())
    {
        Serial.println(F("PICC_IsNewCardPresent : No Card"));
    }
    else
    {
       Serial.println(F("Approach your reader card..."));
    }
    // Select a card
    if (!mfrc522.PICC_ReadCardSerial())
    {
       Serial.println(F("PICC_ReadCardSerial: Read error "));
    }

    output = menu();

    if (output == 0)
        readingData();
    else if (output == 1)
    {
        writingData();
    }
    else
    {
        Serial.println(F("Incorrect Option!"));
        return;
    }
}

/**
 * Helper routine to dump a byte array as hex values to Serial.
 */
void dump_byte_array(byte *buffer, byte bufferSize) {
    for (byte i = 0; i < bufferSize; i++) {
        Serial.print(buffer[i] < 0x10 ? " 0" : " ");
        Serial.print(buffer[i], HEX);
    }
}

// reads data from card/tag
void readingData()
{
    Serial.print(F("Reading data .. \n"));
    showUID();

    // prints the technical details of the card/tag
    mfrc522.PICC_DumpDetailsToSerial(&(mfrc522.uid));

    // prepare the key - all keys are set to FFFFFFFFFFFFh
    for (byte i = 0; i < 6; i++)
        key.keyByte[i] = 0xFF;

    // buffer for read data
    byte buffer[SIZE_BUFFER] = {0};

    // the block to operate
    byte block = 1;
    byte size = SIZE_BUFFER;
    // authenticates the block to operate
    status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(mfrc522.uid)); // line 834 of MFRC522.cpp file
    if (status != MFRC522::STATUS_OK)
    {
        Serial.print(F("Authentication failed: "));
        Serial.println(mfrc522.GetStatusCodeName(status));
    }

    // read data from block
    status = mfrc522.MIFARE_Read(block, buffer, &size);
    if (status != MFRC522::STATUS_OK)
    {
        Serial.print(F("Reading failed: "));
        Serial.println(mfrc522.GetStatusCodeName(status));
        return;
    }
    else
    {
        digitalWrite(LED_PIN, HIGH);
    }

    Serial.print(F("\nData from block ["));
    Serial.print(block);
    Serial.print(F("]: "));

    // prints read data
    for (uint8_t i = 0; i < MAX_SIZE_BLOCK; i++)
    {
        Serial.printf("%c,",buffer[i]);
    }
    Serial.println(" ");

    // Dump debug info about the card; PICC_HaltA() is automatically called
    mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); // call menu function and retrieve the desired option
    
    delay(1000);
    digitalWrite(LED_PIN, LOW);
}

// menu to operation choice
int menu()
{
    Serial.println(F("\nChoose an option:"));
    Serial.println(F("0 - Reading data"));
    Serial.println(F("1 - Writing data\n"));

    // waits while the user does not start data
    while (!Serial.available())
    {
    };

    // retrieves the chosen option
    int op = (int)Serial.read();

    // remove all characters after option (as \n per example)
    while (Serial.available())
    {
        if (Serial.read() == '\n')
            break;
        Serial.read();
    }
    return (op - 48); // subtract 48 from read value, 48 is the zero from ascii table
}

void writingData()
{
    Serial.println(F("Writing data selected .. \n"));
    // prints thecnical details from of the card/tag
    mfrc522.PICC_DumpDetailsToSerial(&(mfrc522.uid));

// waits 30 seconds dor data entry via Serial
Serial.setTimeout(30000L);
Serial.println(F("Enter the data to be written with the '#' character at the end \n[maximum of 16 characters]:"));

// prepare the key - all keys are set to FFFFFFFFFFFFh
for (byte i = 0; i < 6; i++)
    key.keyByte[i] = 0xFF;

// buffer for storing data to write
byte buffer[MAX_SIZE_BLOCK] = "";
byte block;    // the block to operate
byte dataSize; // size of data (bytes)

// recover on buffer the data from Serial
// all characters before chacactere '#'
dataSize = Serial.readBytesUntil('#', (char *)buffer, MAX_SIZE_BLOCK);
// void positions that are left in the buffer will be filled with whitespace
for (byte i = dataSize; i < MAX_SIZE_BLOCK; i++)
{
    buffer[i] = ' ';
}

block = 1;                   // the block to operate
String str = (char *)buffer; // transforms the buffer data in String
Serial.println(str);

// authenticates the block to operate
// Authenticate is a command to hability a secure communication
status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A,
                                  block, &key, &(mfrc522.uid));

if (status != MFRC522::STATUS_OK)
{
    Serial.print(F("PCD_Authenticate() failed: "));
    Serial.println(mfrc522.GetStatusCodeName(status));
    return;
}
else 
   Serial.println(F("PCD_Authenticate() success: "));

// Writes in the block
status = mfrc522.MIFARE_Write(block, buffer, MAX_SIZE_BLOCK);
if (status != MFRC522::STATUS_OK)
{
    Serial.print(F("MIFARE_Write() failed: "));
    Serial.println(mfrc522.GetStatusCodeName(status));
    digitalWrite(LED_PIN, LOW);
    return;
}
else
{
    Serial.println(F("MIFARE_Write() success "));
    digitalWrite(LED_PIN, HIGH);
}

}

void showUID()
{
// Show UID on serial monitor
Serial.print("UID tag :");

String content = "";
byte letter;
for (byte i = 0; i < mfrc522.uid.size; i++)
{
    Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(mfrc522.uid.uidByte[i], HEX);
    content.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
    content.concat(String(mfrc522.uid.uidByte[i], HEX));
}
Serial.println();
Serial.print(content);
}

Documentație proiect


Afiliere eMag

 Linkurile de la secțiunea "Componente" conțin adresa mea de afiliere la eMag.ro, iar dacă cumperi folosind aceste linkuri vei susține blogul meu. Mulțumesc! 

eMag Genius:
Hai și tu în Genius! Abonează-te la Genius 12 luni și primești beneficii premium și 20 lei card cadou eMAG. Profită acum! eMag Genius

Mulțumesc pentru atenție!

Pentru întrebări și/sau consultanță tehnică vă stau la dispoziție pe blog mai jos în secțiunea de comentarii sau pe email simedruflorin@automatic-house.ro. O zi plăcută tuturor !

 Back to top of page


Etichete

Afișați mai multe

Arhiva

Afișați mai multe